import { ref } from 'vue';

/**
 * API调用Hook函数
 * @param {Function} apiFunc 要调用的API函数
 * @param {boolean} immediate 是否立即执行
 * @param {Object} initialData 初始数据
 * @param {Object} fallbackData 降级数据，当API调用失败时使用
 * @returns {Object} API调用相关状态和方法
 */
export function useApi(apiFunc, immediate = false, initialData = null, fallbackData = null) {
  const data = ref(initialData);
  const error = ref(null);
  const loading = ref(false);
  const isFallback = ref(false);
  
  /**
   * 执行API调用
   * @param {...any} args API函数的参数
   * @returns {Promise} API调用的Promise
   */
  const execute = async (...args) => {
    loading.value = true;
    error.value = null;
    isFallback.value = false;
    
    try {
      const response = await apiFunc(...args);
      
      // 检查响应结果是否正确
      if (response.data && response.data.ActionType === 'ok') {
        data.value = response.data.data || response.data;
        isFallback.value = response.data.isUsingFallback || false;
        
        if (isFallback.value) {
          console.info('使用降级数据:', response.data.message);
          // 如果API返回空数据但有降级数据，使用降级数据
          if (Array.isArray(data.value) && data.value.length === 0 && fallbackData) {
            data.value = fallbackData;
          }
        }
        
        return response.data;
      } else {
        // 使用降级数据
        data.value = fallbackData || initialData;
        isFallback.value = true;
        error.value = response.data?.message || '请求失败';
        console.warn('API请求失败，使用降级数据');
        return { data: fallbackData, message: error.value, isUsingFallback: true };
      }
    } catch (err) {
      error.value = err.message || '请求异常';
      console.error('API调用错误:', err);
      // 使用降级数据
      data.value = fallbackData || initialData;
      isFallback.value = true;
      return { data: fallbackData, message: error.value, isUsingFallback: true };
    } finally {
      loading.value = false;
    }
  };
  
  /**
   * 重置状态
   */
  const reset = () => {
    data.value = initialData;
    error.value = null;
    loading.value = false;
    isFallback.value = false;
  };
  
  // 如果需要立即执行
  if (immediate) {
    execute();
  }
  
  return {
    data,
    error,
    loading,
    isFallback,
    execute,
    reset
  };
}

/**
 * 分页API调用Hook函数
 * @param {Function} apiFunc 要调用的API函数
 * @param {Object} options 配置选项
 * @returns {Object} 分页API调用相关状态和方法
 */
export function usePagination(apiFunc, options = {}) {
  const { immediate = false, pageSize = 10, initialPage = 1, fallbackData = [] } = options;
  
  const data = ref([]);
  const error = ref(null);
  const loading = ref(false);
  const currentPage = ref(initialPage);
  const total = ref(0);
  const pageCount = ref(0);
  const isFallback = ref(false);
  
  /**
   * 执行分页API调用
   * @param {Object} params 请求参数，包含page和pageSize
   * @returns {Promise} API调用的Promise
   */
  const loadData = async (params = {}) => {
    loading.value = true;
    error.value = null;
    isFallback.value = false;
    
    try {
      const requestParams = {
        page: params.page || currentPage.value,
        pageSize: params.pageSize || pageSize,
        ...params
      };
      
      const response = await apiFunc(requestParams);
      
      if (response.data && response.data.ActionType === 'ok') {
        data.value = response.data.data || [];
        total.value = response.data.total || 0;
        currentPage.value = requestParams.page;
        pageCount.value = Math.ceil(total.value / requestParams.pageSize);
        isFallback.value = response.data.isUsingFallback || false;
        
        // 如果返回的是空数据，但有降级数据，使用降级数据
        if (data.value.length === 0 && fallbackData.length > 0 && isFallback.value) {
          data.value = fallbackData;
          total.value = fallbackData.length;
          pageCount.value = Math.ceil(total.value / requestParams.pageSize);
        }
        
        return response.data;
      } else {
        throw new Error(response.data?.message || '请求失败');
      }
    } catch (err) {
      error.value = err.message || '请求异常';
      console.error('分页API调用错误:', err);
      // 使用降级数据
      data.value = fallbackData || [];
      total.value = fallbackData.length;
      pageCount.value = Math.ceil(total.value / pageSize);
      isFallback.value = true;
      return { data: fallbackData, message: error.value, isUsingFallback: true };
    } finally {
      loading.value = false;
    }
  };
  
  /**
   * 切换页码
   * @param {number} page 页码
   */
  const changePage = (page) => {
    loadData({ page });
  };
  
  /**
   * 修改每页条数
   * @param {number} size 每页条数
   */
  const changePageSize = (size) => {
    loadData({ page: 1, pageSize: size });
  };
  
  /**
   * 刷新当前页数据
   */
  const refresh = () => {
    loadData();
  };
  
  /**
   * 重置为第一页
   */
  const reset = () => {
    currentPage.value = 1;
    loadData({ page: 1 });
  };
  
  // 如果需要立即执行
  if (immediate) {
    loadData();
  }
  
  return {
    data,
    error,
    loading,
    currentPage,
    total,
    pageCount,
    loadData,
    changePage,
    changePageSize,
    refresh,
    reset
  };
} 